home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / tex / sspell14.zip / ROOT.C < prev    next >
C/C++ Source or Header  |  1992-07-18  |  13KB  |  460 lines
  1. /* **************************************************************** */
  2. /*             sspell - similar to Unix spell                       */
  3. /*                        version 1.4                               */
  4. /*                                                                  */
  5. /* Author: Maurice Castro                                           */
  6. /* Release Date:  4 Jul 1992                                         */
  7. /* Bug Reports: maurice@bruce.cs.monash.edu.au                      */
  8. /*                                                                  */
  9. /* This code has been placed by the Author into the Public Domain.  */
  10. /* The code is NOT covered by any warranty, the user of the code is */
  11. /* solely responsible for determining the fitness of the program    */
  12. /* for their purpose. No liability is accepted by the author for    */
  13. /* the direct or indirect losses incurred through the use of this   */
  14. /* program.                                                         */
  15. /*                                                                  */
  16. /* Segments of this code may be used for any purpose that the user  */
  17. /* deems appropriate. It would be polite to acknowledge the source  */
  18. /* of the code. If you modify the code and redistribute it please   */
  19. /* include a message indicating your changes and how users may      */
  20. /* contact you for support.                                         */
  21. /*                                                                  */
  22. /* The author reserves the right to issue the official version of   */
  23. /* this program. If you have useful suggestions or changes for the  */
  24. /* code, please forward them to the author so that they might be    */
  25. /* incorporated into the official version                           */
  26. /*                                                                  */
  27. /* Please forward bug reports to the author via Internet.           */
  28. /*                                                                  */
  29. /* **************************************************************** */
  30.  
  31. /* determine the root of a word using the rules in the rule file */
  32.  
  33. #include <stdio.h>
  34. #if !defined(pyr)
  35. #include <stdlib.h>
  36. #endif
  37. #include "strfn.h"
  38. #include "root.h"
  39. #include "error.h"
  40. #include "utility.h"
  41. #include "string.h"
  42.  
  43. #define MAXSTR 128
  44. #define PRE 0
  45. #define POST 1
  46.  
  47. typedef struct rule
  48. {
  49.     char *presuf;             /* prefix / suffix */
  50.     char *required;           /* character string  required at end of word */
  51.     char *forbid;             /* character string forbidden at end of word */
  52.     char *del;                /* characters to be deleted from end of word */
  53.     struct rule *next;
  54.     } RULE;
  55.  
  56. RULE *prefixlist;
  57. RULE *suffixlist;
  58.  
  59. void badline(lno)
  60. int lno;
  61. {
  62.    fprintf(stderr, "Warning: line %d in the rule file is badly formed\n",
  63.            lno);
  64.    }
  65.  
  66. void memfail()
  67. {
  68.    errormesg("Error: Out of Memory! Terminating",-3);
  69.    }
  70.  
  71. /* read the rules file */
  72. /* this file is made up of lines of the form: 
  73. /*     pre|post <prefix/suffix> <required> <forbiden> <delete> */
  74. /* Any blank fields should contain a single "-" all fields separated by */
  75. /* white space. A "#" in the first character position indicates a comment */
  76.  
  77. void initroot(file)
  78. char *file;
  79. {
  80.     FILE *f;
  81.     char instr[MAXSTR];
  82.     char *token;
  83.     int lno;
  84.     char *presuf;             /* prefix / suffix */
  85.     char *required;           /* character string  required at end of word */
  86.     char *forbid;             /* character string forbidden at end of word */
  87.     char *del;                /* characters to be deleted from end of word */
  88.     int prepost;
  89.     RULE *newitem;
  90.     RULE *prefixlast;
  91.     RULE *suffixlast;
  92.  
  93.     prefixlist = NULL;
  94.     suffixlist = NULL;
  95.    
  96.     f = fopen(file,"rt");
  97.     lno = -1;
  98.     while (!feof(f))
  99.     {
  100.        if (fgets(instr,MAXSTR-1,f)==NULL)
  101.           break;
  102.        lno++;
  103.        if (instr[0] == '#') 
  104.           continue;                    /* handle comments */
  105.        token = strtok(instr," \t\n");
  106.        if (!strcmp(token, "pre")) 
  107.            prepost = PRE;
  108.        else if (!strcmp(token, "post")) 
  109.            prepost = POST;
  110.        else
  111.        {
  112.            badline(lno);
  113.            continue;
  114.            }
  115.  
  116.        /* deal with the rest of line */
  117.        token = strtok(NULL," \t\n");
  118.        if (token == NULL) 
  119.        {
  120.           badline(lno);
  121.           continue;
  122.           }
  123.        if (!strcmp(token,"-")) 
  124.            presuf = NULL;
  125.        else
  126.        {
  127.            presuf = (char *) malloc(strlen(token)+1); 
  128.            if (presuf == NULL) memfail();
  129.            lstrcpy(presuf,token);
  130.            }
  131.        token = strtok(NULL," \t\n");
  132.        if (token == NULL)
  133.        {
  134.           badline(lno);
  135.           continue;
  136.           }
  137.        if (!strcmp(token,"-")) 
  138.            required = NULL;
  139.        else
  140.        {
  141.            required = (char *) malloc(strlen(token)+1); 
  142.            if (required == NULL) memfail();
  143.            lstrcpy(required,token);
  144.            }
  145.        token = strtok(NULL," \t\n");
  146.        if (token == NULL) 
  147.        {
  148.           badline(lno);
  149.           continue;
  150.           }
  151.        if (!strcmp(token,"-")) 
  152.            forbid = NULL;
  153.        else
  154.        {
  155.            forbid = (char *) malloc(strlen(token)+1); 
  156.            if (forbid == NULL) memfail();
  157.            lstrcpy(forbid,token);
  158.            }
  159.        token = strtok(NULL," \t\n");
  160.        if (token == NULL) 
  161.        {
  162.           badline(lno);
  163.           continue;
  164.           }
  165.        if (!strcmp(token,"-")) 
  166.            del = NULL;
  167.        else
  168.        {
  169.            del = (char *) malloc(strlen(token)+1); 
  170.            if (del == NULL) memfail();
  171.            lstrcpy(del,token);
  172.            }
  173.        newitem = (RULE *) malloc(sizeof(RULE));
  174.        if (newitem == NULL) memfail();
  175.        (*newitem).presuf = presuf;
  176.        (*newitem).required = required;
  177.        (*newitem).forbid = forbid;
  178.        (*newitem).del = del;
  179.        (*newitem).next = NULL;
  180.        if (prepost == PRE)
  181.        {
  182.            if (prefixlist == NULL)
  183.            {
  184.               prefixlist = newitem;
  185.               prefixlast = newitem;
  186.               }
  187.            else
  188.            {
  189.               (*prefixlast).next = newitem;
  190.               prefixlast = newitem;
  191.               }
  192.            }
  193.        else
  194.        {
  195.            if (suffixlist == NULL)
  196.            {
  197.               suffixlist = newitem;
  198.               suffixlast = newitem;
  199.               }
  200.            else
  201.            {
  202.               (*suffixlast).next = newitem;
  203.               suffixlast = newitem;
  204.               }
  205.            }
  206.        }
  207.     fclose(f);
  208.     }
  209.  
  210. int compend(a, b)
  211. char *a;
  212. char *b;
  213. {
  214.    char *sstr;
  215.  
  216.    sstr = a+strlen(a)-strlen(b);
  217.    if (!stricmp(sstr,b))
  218.        return(1);
  219.    return(0);    
  220.    }
  221.  
  222. /* determine the root of a given word */
  223. int prefix(in, outlst)
  224. char *in;
  225. WORDLST **outlst;
  226. {
  227.    RULE *pt;
  228.    char *sstr;
  229.    int idx;
  230.    int outflg;
  231.    WORDLST *newitem;
  232.  
  233.    *outlst = NULL;
  234.    outflg = 0;
  235.  
  236.    pt = prefixlist;
  237.    while (pt != NULL)
  238.    {
  239.       if (!strnicmp(pt->presuf, in, strlen(pt->presuf)))
  240.       { 
  241.          outflg = 1;
  242.          in += (strlen(pt->presuf));
  243.          /* add it to the output list */
  244.          newitem = (WORDLST *) malloc (sizeof(WORDLST));
  245.          newitem->prefix = NULL;
  246.          newitem->suffix = NULL;
  247.          if (newitem == NULL) 
  248.          {
  249.             memfail();
  250.             } 
  251.          newitem->word = (char *) malloc(strlen(in)+1);
  252.          if (newitem->word == NULL) 
  253.          {
  254.             memfail();
  255.             } 
  256.          lstrcpy(newitem->word, in);
  257.          newitem->prefix = (char *) malloc(strlen(pt->presuf)+2);
  258.          if (newitem->prefix == NULL) 
  259.          {
  260.             memfail();
  261.             } 
  262.          lstrcpy(newitem->prefix, pt->presuf);
  263.          strcat(newitem->prefix, "+");
  264.          newitem->next = *outlst;
  265.          *outlst = newitem;
  266.          }
  267.       pt = pt->next;
  268.       }
  269.    if (outflg) return(1);
  270.    return(0);
  271.    }
  272.  
  273. int suffix(in, outlst)
  274. char *